home *** CD-ROM | disk | FTP | other *** search
/ All for Cell Phones: Sony Ericsson / Sony-Ericsson 2004.iso / Java / MicroCalc / MicroCalc.jar / MathFP.class (.txt) < prev    next >
Encoding:
Java Class File  |  2001-11-07  |  5.7 KB  |  405 lines
  1. public abstract class MathFP {
  2.    // $FF: renamed from: if int
  3.    private static int field_0 = 24;
  4.    // $FF: renamed from: int int
  5.    private static int field_1 = 8;
  6.    // $FF: renamed from: new long
  7.    private static long field_2 = 16777216L;
  8.    // $FF: renamed from: do long
  9.    private static long field_3 = 16777215L;
  10.    // $FF: renamed from: byte long
  11.    private static long field_4 = 100000000L;
  12.    // $FF: renamed from: try long
  13.    private static long field_5 = 0L;
  14.    // $FF: renamed from: a long
  15.    private static long field_6 = 52707178L;
  16.    // $FF: renamed from: for long[]
  17.    private static long[] field_7;
  18.    // $FF: renamed from: PI long
  19.    public static long field_8;
  20.    // $FF: renamed from: E long
  21.    public static long field_9;
  22.    public static final long MAX_VALUE = Long.MAX_VALUE;
  23.    public static final long MIN_VALUE = -9223372036854775807L;
  24.  
  25.    static {
  26.       field_7 = new long[]{field_2, 45605201L, 123967790L, 336979391L, 916004956L};
  27.       field_8 = field_6;
  28.       field_9 = field_7[1];
  29.    }
  30.  
  31.    public static long abs(long var0) {
  32.       return var0 < 0L ? -var0 : var0;
  33.    }
  34.  
  35.    public static long acos(long var0) {
  36.       return field_8 / 2L - asin(var0);
  37.    }
  38.  
  39.    public static long add(long var0, long var2) {
  40.       return var0 + var2;
  41.    }
  42.  
  43.    public static long asin(long var0) {
  44.       if (abs(var0) > field_2) {
  45.          throw new ArithmeticException("Bad Input");
  46.       } else {
  47.          boolean var2 = var0 < 0L;
  48.          var0 = abs(var0);
  49.          long var3 = mul(mul(mul(mul((long)(145103 >> (int)field_5), var0) - (long)(599880 >> (int)field_5), var0) + (long)(1420468 >> (int)field_5), var0) - (long)(3592413 >> (int)field_5), var0) + (long)(26353447 >> (int)field_5);
  50.          long var5 = field_8 / 2L - mul(sqrt(field_2 - var0), var3);
  51.          return var2 ? -var5 : var5;
  52.       }
  53.    }
  54.  
  55.    public static long atan(long var0) {
  56.       return asin(div(var0, sqrt(field_2 + mul(var0, var0))));
  57.    }
  58.  
  59.    public static long atan2(long var0, long var2) {
  60.       long var4 = 0L;
  61.       if (var2 > 0L) {
  62.          var4 = atan(div(var0, var2));
  63.       } else if (var2 < 0L) {
  64.          var4 = (var2 < 0L ? -field_8 : field_8) - atan(abs(div(var0, var2)));
  65.       } else {
  66.          if (var2 == 0L && var0 == 0L) {
  67.             throw new ArithmeticException("Bad Input");
  68.          }
  69.  
  70.          var4 = (var0 < 0L ? -field_8 : field_8) / 2L;
  71.       }
  72.  
  73.       return var4;
  74.    }
  75.  
  76.    public static long convert(long var0, int var2) {
  77.       long var3 = (long)(var0 < 0L ? -1 : 1);
  78.       if (abs((long)var2) < 25L) {
  79.          if (field_0 < var2) {
  80.             var0 = var0 + var3 * (1L << (var2 - field_0 >> 1)) >> var2 - field_0;
  81.          } else {
  82.             var0 <<= field_0 - var2;
  83.          }
  84.       }
  85.  
  86.       return var0;
  87.    }
  88.  
  89.    public static long cos(long var0) {
  90.       return sin(field_8 / 2L - var0);
  91.    }
  92.  
  93.    public static long cot(long var0) {
  94.       return div(cos(var0), sin(var0));
  95.    }
  96.  
  97.    public static long div(long var0, long var2) {
  98.       boolean var4 = false;
  99.       int var5 = field_0;
  100.       if (var2 == field_2) {
  101.          return var0;
  102.       } else if ((var2 & field_3) == 0L) {
  103.          return var0 / (var2 >> var5);
  104.       } else {
  105.          if (var0 < 0L && var2 > 0L || var0 > 0L && var2 < 0L) {
  106.             var4 = true;
  107.          }
  108.  
  109.          if (var0 < 0L) {
  110.             var0 = -var0;
  111.          }
  112.  
  113.          if (var2 < 0L) {
  114.             var2 = -var2;
  115.          }
  116.  
  117.          while(max(var0, var2) >= 1L << 63 - var5) {
  118.             var0 >>= 1;
  119.             var2 >>= 1;
  120.             --var5;
  121.          }
  122.  
  123.          long var6 = (var0 << var5) / var2 << field_0 - var5;
  124.          return var4 ? -var6 : var6;
  125.       }
  126.    }
  127.  
  128.    public static long exp(long var0) {
  129.       if (var0 == 0L) {
  130.          return field_2;
  131.       } else {
  132.          boolean var2 = var0 < 0L;
  133.          var0 = abs(var0);
  134.          int var3 = (int)(var0 >> field_0);
  135.          long var4 = field_2;
  136.  
  137.          for(int var6 = 0; var6 < var3 / 4; ++var6) {
  138.             var4 = mul(var4, field_7[4] >> (int)field_5);
  139.          }
  140.  
  141.          if (var3 % 4 > 0) {
  142.             var4 = mul(var4, field_7[var3 % 4] >> (int)field_5);
  143.          }
  144.  
  145.          var0 &= field_3;
  146.          if (var0 > 0L) {
  147.             long var7 = field_2;
  148.             long var9 = 0L;
  149.             long var11 = 1L;
  150.  
  151.             for(int var13 = 0; var13 < 16; ++var13) {
  152.                var9 += var7 / var11;
  153.                var7 = mul(var7, var0);
  154.                var11 *= (long)(var13 + 1);
  155.                if (var11 > var7 || var7 <= 0L || var11 <= 0L) {
  156.                   break;
  157.                }
  158.             }
  159.  
  160.             var4 = mul(var4, var9);
  161.          }
  162.  
  163.          if (var2) {
  164.             var4 = div(field_2, var4);
  165.          }
  166.  
  167.          return var4;
  168.       }
  169.    }
  170.  
  171.    public static int getPrecision() {
  172.       return field_0;
  173.    }
  174.  
  175.    public static long log(long var0) {
  176.       // $FF: Couldn't be decompiled
  177.    }
  178.  
  179.    public static long max(long var0, long var2) {
  180.       return var0 < var2 ? var2 : var0;
  181.    }
  182.  
  183.    public static long min(long var0, long var2) {
  184.       return var2 < var0 ? var2 : var0;
  185.    }
  186.  
  187.    public static long mul(long var0, long var2) {
  188.       boolean var4 = false;
  189.       int var5 = field_0;
  190.       long var6 = field_3;
  191.       if ((var0 & var6) == 0L) {
  192.          return (var0 >> var5) * var2;
  193.       } else if ((var2 & var6) == 0L) {
  194.          return var0 * (var2 >> var5);
  195.       } else {
  196.          if (var0 < 0L && var2 > 0L || var0 > 0L && var2 < 0L) {
  197.             var4 = true;
  198.          }
  199.  
  200.          if (var0 < 0L) {
  201.             var0 = -var0;
  202.          }
  203.  
  204.          if (var2 < 0L) {
  205.             var2 = -var2;
  206.          }
  207.  
  208.          while(max(var0, var2) >= 1L << 63 - var5) {
  209.             var0 >>= 1;
  210.             var2 >>= 1;
  211.             var6 >>= 1;
  212.             --var5;
  213.          }
  214.  
  215.          long var8 = (var0 >> var5) * (var2 >> var5) << var5;
  216.          long var10 = (var0 & var6) * (var2 & var6) >> var5;
  217.          var10 += (var0 & ~var6) * (var2 & var6) >> var5;
  218.          var8 = var8 + var10 + ((var0 & var6) * (var2 & ~var6) >> var5) << field_0 - var5;
  219.          if (var8 < 0L) {
  220.             throw new ArithmeticException("Overflow");
  221.          } else {
  222.             return var4 ? -var8 : var8;
  223.          }
  224.       }
  225.    }
  226.  
  227.    public static long pow(long var0, long var2) {
  228.       boolean var4 = var2 < 0L;
  229.       long var5 = field_2;
  230.       var2 = abs(var2);
  231.  
  232.       for(int var7 = (int)var2 >> field_0; var7-- > 0; var5 = mul(var5, var0)) {
  233.       }
  234.  
  235.       if (var5 < 0L) {
  236.          throw new ArithmeticException("Overflow");
  237.       } else {
  238.          if (var0 != 0L) {
  239.             var5 = mul(var5, exp(mul(log(var0), var2 & field_3)));
  240.          } else {
  241.             var5 = 0L;
  242.          }
  243.  
  244.          return var4 ? div(field_2, var5) : var5;
  245.       }
  246.    }
  247.  
  248.    public static long round(long var0, int var2) {
  249.       long var3 = 10L;
  250.  
  251.       for(int var5 = 0; var5 < var2; ++var5) {
  252.          var3 *= 10L;
  253.       }
  254.  
  255.       var3 = div(toFP(5L), toFP(var3));
  256.       if (var0 < 0L) {
  257.          var3 = -var3;
  258.       }
  259.  
  260.       return var0 + var3;
  261.    }
  262.  
  263.    public static int setPrecision(int var0) {
  264.       if (var0 <= 24 && var0 >= 0) {
  265.          field_0 = var0;
  266.          field_2 = 1L << var0;
  267.          field_5 = (long)(24 - var0);
  268.          field_1 = 0;
  269.          field_4 = 1L;
  270.          field_3 = field_2 - 1L;
  271.          field_8 = field_6 >> (int)field_5;
  272.          field_9 = field_7[1] >> (int)field_5;
  273.  
  274.          for(long var1 = field_2; var1 != 0L; field_4 *= 10L) {
  275.             var1 /= 10L;
  276.             ++field_1;
  277.          }
  278.  
  279.          return field_1;
  280.       } else {
  281.          return field_1;
  282.       }
  283.    }
  284.  
  285.    public static long sin(long var0) {
  286.       long var2 = mul(var0, div(toFP(180L), field_8));
  287.       var2 %= toFP(360L);
  288.       if (var2 < 0L) {
  289.          var2 += toFP(360L);
  290.       }
  291.  
  292.       long var4 = var2;
  293.       if (var2 >= toFP(90L) && var2 < toFP(270L)) {
  294.          var4 = toFP(180L) - var2;
  295.       } else if (var2 >= toFP(270L) && var2 < toFP(360L)) {
  296.          var4 = -(toFP(360L) - var2);
  297.       }
  298.  
  299.       long var6 = var4 / 90L;
  300.       long var8 = mul(var6, var6);
  301.       long var10 = mul(mul(mul(mul(-73190L >> (int)field_5, var8) + (1333581L >> (int)field_5), var8) - (10836755L >> (int)field_5), var8) + (long)(26353564 >> (int)field_5), var6);
  302.       return var10;
  303.    }
  304.  
  305.    public static long sqrt(long var0) {
  306.       return sqrt(var0, 24);
  307.    }
  308.  
  309.    public static long sqrt(long var0, int var2) {
  310.       if (var0 < 0L) {
  311.          throw new ArithmeticException("Bad Input");
  312.       } else if (var0 == 0L) {
  313.          return 0L;
  314.       } else {
  315.          long var3 = var0 + field_2 >> 1;
  316.  
  317.          for(int var5 = 0; var5 < var2; ++var5) {
  318.             var3 = var3 + div(var0, var3) >> 1;
  319.          }
  320.  
  321.          if (var3 < 0L) {
  322.             throw new ArithmeticException("Overflow");
  323.          } else {
  324.             return var3;
  325.          }
  326.       }
  327.    }
  328.  
  329.    public static long sub(long var0, long var2) {
  330.       return var0 - var2;
  331.    }
  332.  
  333.    public static long tan(long var0) {
  334.       return div(sin(var0), cos(var0));
  335.    }
  336.  
  337.    public static long toFP(long var0) {
  338.       return var0 << field_0;
  339.    }
  340.  
  341.    public static long toFP(String var0) {
  342.       byte var1 = 0;
  343.       if (var0.charAt(0) == '-') {
  344.          var1 = 1;
  345.       }
  346.  
  347.       String var2 = "-1";
  348.       int var3 = var0.indexOf(46);
  349.       if (var3 >= 0) {
  350.          for(var2 = var0.substring(var3 + 1, var0.length()); var2.length() < field_1; var2 = var2 + "0") {
  351.          }
  352.  
  353.          if (var2.length() > field_1) {
  354.             var2 = var2.substring(0, field_1);
  355.          }
  356.       } else {
  357.          var3 = var0.length();
  358.       }
  359.  
  360.       long var4 = 0L;
  361.       if (var1 != var3) {
  362.          var4 = Long.parseLong(var0.substring(var1, var3));
  363.       }
  364.  
  365.       long var6 = Long.parseLong(var2) + 1L;
  366.       long var8 = (var4 << field_0) + (var6 << field_0) / field_4;
  367.       if (var1 == 1) {
  368.          var8 = -var8;
  369.       }
  370.  
  371.       return var8;
  372.    }
  373.  
  374.    public static long toLong(long var0) {
  375.       var0 = round(var0, 0);
  376.       return var0 >> field_0;
  377.    }
  378.  
  379.    public static String toString(long var0) {
  380.       boolean var2 = false;
  381.       if (var0 < 0L) {
  382.          var2 = true;
  383.          var0 = -var0;
  384.       }
  385.  
  386.       long var3 = var0 >> field_0;
  387.       long var5 = field_4 * (var0 & field_3) >> field_0;
  388.  
  389.       String var7;
  390.       for(var7 = Long.toString(var5); var7.length() < field_1; var7 = "0" + var7) {
  391.       }
  392.  
  393.       return (var2 ? "-" : "") + Long.toString(var3) + "." + var7;
  394.    }
  395.  
  396.    public static String toString(long var0, int var2) {
  397.       if (var2 > field_1) {
  398.          var2 = field_1;
  399.       }
  400.  
  401.       String var3 = toString(round(var0, var2));
  402.       return var3.substring(0, var3.length() - field_1 + var2);
  403.    }
  404. }
  405.